from django.core.management.base import BaseCommand
from django.contrib.auth.models import User
from django.db import transaction
from django.utils import timezone
from battles.models import BattleStatistics
from codes.models import Code, CodeFile, CodeVersion
import random
import string


class Command(BaseCommand):
    help = '创建16个测试用户，并为每个用户创建代码项目，使用排行榜第一名的代码'

    def add_arguments(self, parser):
        parser.add_argument(
            '--prefix',
            type=str,
            default='testuser',
            help='用户名前缀，默认为testuser',
        )
        parser.add_argument(
            '--password',
            type=str,
            default='testpass123',
            help='用户密码，默认为testpass123',
        )
        parser.add_argument(
            '--count',
            type=int,
            default=16,
            help='创建用户数量，默认为16',
        )
        parser.add_argument(
            '--force',
            action='store_true',
            help='强制删除已存在的测试用户并重新创建',
        )
        parser.add_argument(
            '--delete-only',
            action='store_true',
            help='仅删除指定前缀的用户，不创建新用户',
        )

    def handle(self, *args, **options):
        prefix = options['prefix']
        password = options['password']
        count = options['count']
        force = options['force']
        delete_only = options['delete_only']
        
        # 如果只是删除用户
        if delete_only:
            self.stdout.write(f'删除前缀为 "{prefix}" 的用户')
            self.delete_users_by_prefix(prefix)
            return
        
        self.stdout.write('开始创建测试用户和代码项目...')
        
        # 获取排行榜第一名的代码
        top_user_code = self.get_top_user_code()
        if not top_user_code:
            self.stdout.write(
                self.style.ERROR('未找到可复制的代码项目，请确保系统中至少有一个用户拥有代码项目')
            )
            return
            
        self.stdout.write(f'找到排行榜第一名用户: {top_user_code.user.username}')
        self.stdout.write(f'将复制代码项目: {top_user_code.title}')
        
        created_users = []
        
        # 如果使用force选项，先删除已存在的测试用户
        if force:
            self.delete_users_by_prefix(prefix)
        
        # 创建指定数量的测试用户
        for i in range(1, count + 1):
            username = f'{prefix}{i:02d}'
            
            # 检查用户是否已存在
            if User.objects.filter(username=username).exists():
                if not force:
                    self.stdout.write(
                        self.style.WARNING(f'用户 {username} 已存在，跳过创建')
                    )
                    continue
            
            with transaction.atomic():
                try:
                    # 创建用户
                    user = User.objects.create_user(
                        username=username,
                        password=password,
                        email=f'{username}@example.com',
                        first_name=f'Test',
                        last_name=f'User {i:02d}',
                        is_active=True
                    )
                    
                    # 创建用户统计记录（如果不存在）
                    battle_stats, created = BattleStatistics.objects.get_or_create(
                        user=user,
                        defaults={
                            'total_battles': 0,
                            'wins': 0,
                            'losses': 0,
                            'draws': 0,
                            'total_score': 0,
                            'average_score': 0.0,
                            'best_score': 0,
                            'rating': 1000,  # 默认评分
                            'current_rank': 0,
                            'highest_rank': 0,
                        }
                    )
                    if created:
                        self.stdout.write(f'为用户 {username} 创建了战斗统计记录')
                    else:
                        self.stdout.write(f'用户 {username} 的战斗统计记录已存在')
                    
                    # 复制排行榜第一名的代码项目
                    self.copy_code_project(user, top_user_code)
                    
                    created_users.append(user)
                    self.stdout.write(
                        self.style.SUCCESS(f'成功创建用户: {username}')
                    )
                    
                except Exception as e:
                    self.stdout.write(
                        self.style.ERROR(f'创建用户 {username} 失败: {str(e)}')
                    )
        
        self.stdout.write(
            self.style.SUCCESS(f'成功创建 {len(created_users)} 个测试用户')
        )
        
        # 显示创建的用户列表
        if created_users:
            self.stdout.write('\n创建的用户列表:')
            for user in created_users:
                self.stdout.write(f'  - {user.username} (密码: {password})')
    
    def delete_users_by_prefix(self, prefix):
        """删除指定前缀的用户"""
        existing_users = User.objects.filter(username__startswith=prefix)
        if not existing_users.exists():
            self.stdout.write(
                self.style.WARNING(f'未找到前缀为 "{prefix}" 的用户')
            )
            return
        
        user_count = existing_users.count()
        user_list = list(existing_users.values_list('username', flat=True))
        
        self.stdout.write(f'找到 {user_count} 个前缀为 "{prefix}" 的用户:')
        for username in user_list:
            self.stdout.write(f'  - {username}')
        
        # 删除用户（Django会自动处理相关的外键关系）
        existing_users.delete()
        
        self.stdout.write(
            self.style.SUCCESS(f'成功删除 {user_count} 个用户')
        )
    
    def get_top_user_code(self):
        """获取排行榜第一名用户的代码项目"""
        # 获取所有非管理员用户的统计数据
        all_users = User.objects.filter(is_staff=False).order_by('id')
        user_stats_list = []

        for user in all_users:
            try:
                stats = BattleStatistics.objects.get(user=user)
            except BattleStatistics.DoesNotExist:
                # 为没有统计记录的用户创建默认统计对象
                stats = BattleStatistics(
                    user=user,
                    total_battles=0,
                    wins=0,
                    losses=0,
                    draws=0,
                    total_score=0,
                    average_score=0.0,
                    best_score=0,
                    rating=0,
                    current_rank=0,
                    highest_rank=0,
                )
            user_stats_list.append(stats)

        # 按照排行榜逻辑排序
        sorted_stats = sorted(user_stats_list, key=lambda x: (
            x.total_battles == 0,  # 未参与战斗的排在最后
            -x.wins,               # 胜场数降序
            -x.draws,              # 平局数降序  
            x.losses,              # 负场数升序（越少越好）
            -x.rating              # 评分降序
        ))
        
        # 找到第一名用户的代码项目
        for stats in sorted_stats:
            user_codes = Code.objects.filter(user=stats.user, is_active=True)
            if user_codes.exists():
                return user_codes.first()
        
        # 如果排行榜第一名没有代码，找任意一个有代码的用户
        for user in User.objects.filter(is_staff=False):
            user_codes = Code.objects.filter(user=user, is_active=True)
            if user_codes.exists():
                return user_codes.first()
        
        return None
    
    def copy_code_project(self, target_user, source_code):
        """复制代码项目到目标用户"""
        try:
            with transaction.atomic():
                # 创建新的代码项目
                new_code = Code.objects.create(
                    user=target_user,
                    title=f'{source_code.title} (复制)',
                    description=f'复制自用户 {source_code.user.username} 的代码项目',
                    language=source_code.language,
                    is_active=True,
                    is_public=True
                )
                
                # 复制所有代码文件
                source_files = source_code.files.all()
                for source_file in source_files:
                    CodeFile.objects.create(
                        code=new_code,
                        file_path=source_file.file_path,
                        file_name=source_file.file_name,
                        content=source_file.content,
                        file_size=source_file.file_size,
                        is_main=source_file.is_main
                    )
                
                # 复制最新版本（如果存在版本系统）
                latest_version = source_code.get_latest_version()
                if latest_version:
                    CodeVersion.objects.create(
                        code=new_code,
                        version_number=1,
                        content=latest_version.content,
                        commit_message=f'初始版本 - 复制自 {source_code.user.username}',
                        file_size=latest_version.file_size
                    )
                
                self.stdout.write(f'  成功复制代码项目: {new_code.title}')
                
        except Exception as e:
            self.stdout.write(
                self.style.ERROR(f'复制代码项目失败: {str(e)}')
            )
            raise